{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Build Synapses"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Contents**\n",
    "\n",
    "- [brainpy.SynType](#brainpy.SynType)\n",
    "- [brainpy.SynConn](#brainpy.SynConn)\n",
    "- [brainpy.connect](#brainpy.connect)\n",
    "- [Other Operations](#Other-Operations)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Same with the neuron models, the *definition* and *usage* of the synapse model are separated from each other. Specifically, two classes should be used:\n",
    "\n",
    "- ``brainpy.SynType``: Define the abstract synapse model.\n",
    "- ``brainpy.SynConn``: Use the abstract synapse model to generate a concrete synapse connection."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The synapse model should consider two things:\n",
    "\n",
    "- The ``connection`` between neuron groups: how the pre-synaptic neurons connect to the post-synaptic neurons.\n",
    "- What ``computation`` is used on each synaptic connection. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the next, I will illustrate how to define a synaptic model by using ``brainpy.SynType``, and then tell you how to use your defined model with ``brainpy.SynConn``. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Before we start, let's import your favorite BrainPy and NumPy packages."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-03T15:26:16.382159Z",
     "start_time": "2021-02-03T15:26:13.341526Z"
    }
   },
   "outputs": [],
   "source": [
    "import brainpy as bp\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## brainpy.SynType"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Support for `SynType` definition"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Same with the neuron models, BrainPy provides several interfaces to support the SynType definition. Users can combine them arbitrarily to define a synapse model. Specifically, the supports include:\n",
    "\n",
    "- **Numerical integration of [differential equations](https://brainpy.readthedocs.io/en/latest/advanced/differential_equations.html)**: by using the decorator `@brainpy.integrate`, users can define an integrator for a ODE or SDE. The numerical method for integration can be chosen from the supported [methods](https://brainpy.readthedocs.io/en/latest/advanced/numerical_integrators.html).\n",
    "\n",
    "- **Synaptic state management**: BrainPy provides `brainpy.SynState` for convenient synapse state management. \n",
    "\n",
    "- **Automatical synaptic delay**: The synapse modeling usually includes a delay time (typically 0.3–0.5 ms) required for a neurotransmitter to be released from a presynaptic membrane, diffuse across the synaptic cleft, and bind to a receptor site on the post-synaptic membrane. BrainPy provides `@brainpy.delayed` decorator for automatical state delay. On the functions which use the delayed state, you just need to add the `@delayed` decorator on them. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Scalar-based Synapse Model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The updating logic of a synapse should consider the connections between groups and the computations on each connection. Fortunately, BrainPy provides a scalar-based definition paradigm, in which you only need to consider the computation on each connection. Let's first take the AMPA synapse model as an illustrating example."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The formal equations of an AMPA synapse is given by:\n",
    "\n",
    "$$\n",
    "\\frac{d s}{d t}=-\\frac{s}{\\tau_{decay}}+\\sum_{k} \\delta(t-t_{j}^{k}) \\quad (1) \\\\\n",
    "I_{syn}= \\bar{g}_{syn} s (V-E_{syn}) \\quad (2)\n",
    "$$\n",
    "\n",
    "\n",
    "where $\\bar{g}_{syn}$ is the maximum synaptic conductance, $s$ is the gating variable, and $V$ is the membrane potential of the postsynaptic neuron. The time constant $\\tau_{decay}$ is about 2ms and the equilibrium potential $E_{syn}$ for AMPA synapse is set to 0 mV."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-03T15:26:16.390139Z",
     "start_time": "2021-02-03T15:26:16.385153Z"
    }
   },
   "outputs": [],
   "source": [
    "# model parameters \n",
    "\n",
    "tau_decay = 2.   # time constant of the dacay after synapse respond to a neurontransmitter.\n",
    "g_max = .10      # Voltage-controlled conductance per unit area\n",
    "                 # associated with the Sodium (Na) and Potassium (K) \n",
    "                 # ion-channels on the synapse (postsynaptic membrane).\n",
    "E = 0.           # The equilibrium potentials for the synapse."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-03T15:26:16.482890Z",
     "start_time": "2021-02-03T15:26:16.394130Z"
    }
   },
   "outputs": [],
   "source": [
    "# use \"@integrate\" to define the gating variable dynamics\n",
    "\n",
    "@bp.integrate\n",
    "def int_s(s, t):\n",
    "    return - s / tau_decay"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-03T15:26:16.490869Z",
     "start_time": "2021-02-03T15:26:16.485884Z"
    }
   },
   "outputs": [],
   "source": [
    "# use \"SynState\" to define the synapse state\n",
    "\n",
    "ST = bp.SynState('s', help='AMPA synapse state.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Based on the above definition, the update logic of the synapse model (equation (1)) from the current time point ($t$) to the next time point $(t + dt)$ can be defined as:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-03T15:26:16.502838Z",
     "start_time": "2021-02-03T15:26:16.494858Z"
    }
   },
   "outputs": [],
   "source": [
    "def update_by_scalar(ST, _t, pre):\n",
    "    s = int_s(ST['s'], _t)\n",
    "    if pre['spike'] == True:\n",
    "        s += 1\n",
    "    ST['s'] = s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The output synaptic value onto the post-synaptic neurons (equation (2)) can be defined as:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-03T15:26:16.512811Z",
     "start_time": "2021-02-03T15:26:16.505831Z"
    }
   },
   "outputs": [],
   "source": [
    "@bp.delayed\n",
    "def output_by_scalar(ST, post):\n",
    "    I_syn = - g_max * ST['s'] * (post['V'] - E)\n",
    "    post['input'] += I_syn"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, the code writting is very similar to the original equations. \n",
    "\n",
    "Another thing we should pay attention to is that the `update()` function needs pre-synaptic neuron state `pre`, and the `output()` function requires post-synaptic neuron state `post`. If you want someone else to use this model, you can make clear statements about the data need to satisfy (optional). Like this,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-03T15:26:16.529765Z",
     "start_time": "2021-02-03T15:26:16.515802Z"
    }
   },
   "outputs": [],
   "source": [
    "requires = dict(\n",
    "    pre=bp.types.NeuState('spike', help='Presynaptic neuron state must have \"spike\" item.'),\n",
    "    post=bp.types.NeuState('V', 'input', help='Postsynaptic neuron state must have \"V\" and \"input\" item.')\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Putting together, an AMPA synapse model is defined as:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-03T15:26:16.547718Z",
     "start_time": "2021-02-03T15:26:16.535751Z"
    }
   },
   "outputs": [],
   "source": [
    "AMPA1 = bp.SynType(name='AMPA_scalar',  ST=ST, requires=requires, \n",
    "                   steps=(update_by_scalar, output_by_scalar), mode='scalar')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Matrix-based Synapse Model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Contrary to the scalar-based synapse model, the matrix-based model means each item in the synapse state ``ST`` is a matrix with the shape of `(num_pre, num_post)`. And the updating logic in the matrix-based model will explicitly utilize the synaptic connections (i.e., connectivity matrix with the shape of `(num_pre, num_post)`). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For example, if you have the followng connection matrix (`conn_mat`), \n",
    "\n",
    "\n",
    "<img src=\"../images/syn-example-conn_mat.png\" width=\"400 px\" align=\"left\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "the updating logic of the AMPA synapse can be coded as:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-03T15:26:16.557691Z",
     "start_time": "2021-02-03T15:26:16.551707Z"
    }
   },
   "outputs": [],
   "source": [
    "def update_by_mat(ST, _t, pre, conn_mat):\n",
    "    s = int_s(ST['s'], _t)\n",
    "    # when pre-synaptic neuron generate spikes, the  \n",
    "    # corresponding position in `s` will add 1.\n",
    "    s += pre['spike'].reshape((-1, 1)) * conn_mat\n",
    "    ST['s'] = s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similarly, the output function of the AMPA synapse will be adapted to"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-03T15:26:16.568660Z",
     "start_time": "2021-02-03T15:26:16.561682Z"
    }
   },
   "outputs": [],
   "source": [
    "@bp.delayed\n",
    "def output_by_mat(ST, post):\n",
    "    g = g_max * np.sum(ST['s'], axis=0)\n",
    "    post['input'] -= g * (post['V'] - E)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, in order to compute the AMPA updating logic, a new data `conn_mat` will be used. We can make a data declaration as (optional)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-03T15:26:16.578635Z",
     "start_time": "2021-02-03T15:26:16.571653Z"
    }
   },
   "outputs": [],
   "source": [
    "requires = dict(\n",
    "    pre=bp.types.NeuState('spike'),\n",
    "    post=bp.types.NeuState('V', 'input'),\n",
    "    conn_mat=bp.types.MatConn(help='Connection matrix between pre- and post- synaptic neuron group.')\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Putting together, a matrix-based AMPA synapse model is defined as"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-03T15:26:16.597585Z",
     "start_time": "2021-02-03T15:26:16.582625Z"
    }
   },
   "outputs": [],
   "source": [
    "AMPA2 = bp.SynType(name='AMPA_matrix',  ST=ST, requires=requires, \n",
    "                   steps=(update_by_mat, output_by_mat), mode='matrix')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Event-based upating**\n",
    "\n",
    "The computation logic defined in `update_by_mat()` is very inefficient. This is because it is uncommon for a neuron to generate a spike, and in a group of neuron, the generated spikes (`pre['spike']`) are usually sparse. Therefore, for many time points, there are many zeros in `pre['spike']`, which results `s` add many unnecessary zeros (`s += pre['spike'].reshape((-1, 1)) * conn_mat`). Alternatively, we can update `s` when the pre-synaptic neuron produces a spike event:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-03T15:26:16.608554Z",
     "start_time": "2021-02-03T15:26:16.600576Z"
    }
   },
   "outputs": [],
   "source": [
    "def update_by_mat(ST, _t, pre, conn_mat):\n",
    "    s = int_s(ST['s'], _t)\n",
    "    \n",
    "    # event-based updating\n",
    "    for i in range(pre['spike'].shape[0]):\n",
    "        if pre['spike'][i] > 0:\n",
    "            s[i] += conn_mat[i]\n",
    "    \n",
    "    ST['s'] = s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In such a way, only when pre neuron $i$ produces a spike, the correponding `s[i]` will carry out the adding operation (`s[i] += conn_mat[i]`). In practice, this kind of updating method is much more efficient than the previous one."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Vector-based Synapse Model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Matrix-based model may be straightforward, but can cause severe wasted RAM memory and inefficient computation. Imaging you want to connect 10,000 pre-synaptic neurons to 10,000 post-synaptic neurons with a 10% random probability. Using *matrix*, you need $10^8$ floats to save the synaptic state, and at each update step, you need do computation on $10^8$ floats (for example, the computation in the above `int_s()`). Actually, the number of values you truely needed is $10^7$. See, there is a huge memory waste and computing resource inefficiency. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An effective method to solve this problem is to use *vector* to store the connectivity between neuron groups and the corresponding synaptic states. For the above defined connectivity `conn_mat`, we can align the connected pre-synaptic neurons and the post-synaptic neurons by two one-dimensional arrays: *pre_ids* and *post_ids*,"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"../images/syn-example-pre_ids-post_ids.png\" width=\"700 px\" align=\"left\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In such a way, we only need two vectors (each has $10^7$ floats). And, at each time step, we just compute `int_s()` on a synaptic state vector with $10^7$ floats. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, the synaptic computation based on vectors also has problems. That is, how to retrieve the synapse states which connected with the pre-synaptic neuron $i$ and the post-synaptic neuron $j$. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A simple way is to create a `pre2syn` list, where each `pre2syn[i]` stores the synaptic state indexes projected from the pre-synaptic neuron $i$.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"../images/syn-example-pre2syn.png\" width=\"200 px\" align=\"left\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similarly, we can create a `post2syn` list to indicate the connections between synapses and postsynaptic neurons. For each post-synaptic neuron $j$, `post2syn[j]` stores the indexes of synaptic elements which connected to post neuron $j$. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"../images/syn-example-post2syn.png\" width=\"200 px\" align=\"left\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Also, the direct mapping between the pre-synaptic neurons and the post-synaptic neurons can be established. `pre2post` saves the connected post-synaptic neurons indexes, in which `pre2post[i]` retrieves the post neuron ids projected from pre-synaptic neuron $i$. `post2pre` saves the pre-synaptic neurons indexes, in which `post2pre[j]` retrieves the pre-syanptic neuron ids which project to post-synaptic neuron $j$. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"../images/syn-example-pre2post.png\" width=\"200 px\" align=\"left\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"../images/syn-example-post2pre.png\" width=\"200 px\" align=\"left\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Based on these connectivity mappings, we can define another version of AMPA synapse model by using `pre2syn` and `post2syn`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-03T15:26:16.638474Z",
     "start_time": "2021-02-03T15:26:16.612544Z"
    }
   },
   "outputs": [],
   "source": [
    "def update_by_vector(ST, _t, pre, pre2syn):\n",
    "    s = ints(ST['s'], _t)\n",
    "    \n",
    "    for i in range(pre['spike'].shape[0]):\n",
    "        if pre['spike'][i] > 0:\n",
    "            # if pre[i] produce a spike, then the  \n",
    "            # connected synapses should add 1.\n",
    "            syn_ids = pre2syn[i]\n",
    "            s[syn_ids] += 1.\n",
    "\n",
    "    ST['s'] = s\n",
    "\n",
    "@bp.delayed\n",
    "def output_by_vector(ST, post, post2syn):\n",
    "    g = np.zeros(len(post2syn), dtype=np.float_)\n",
    "    for post_id, syn_ids in enumerate(post2syn):\n",
    "        g[post_id] = np.sum(g_max * ST['s'][syn_ids])\n",
    "    \n",
    "    post['input'] -= post_cond * (post['V'] - E)\n",
    "    \n",
    "requires = dict(\n",
    "    pre=bp.types.NeuState('spike'),\n",
    "    post=bp.types.NeuState('V', 'input'),\n",
    "    pre2syn = bp.types.ListConn(),\n",
    "    post2syn = bp.types.ListConn()\n",
    ")\n",
    "\n",
    "AMPA3 = bp.SynType(name='AMPA_vector', ST=ST,  requires=requires,\n",
    "                   steps=(update_by_vector, output_by_vector),  mode='vector')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, we get a vector-based synapse model. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, it is not perfect. This is because the computation of `s` and `g` relies on many indexing (`s[syn_ids]` and `ST['s'][syn_ids]`). When the number of the connected pre/post-synaptic neurons is big, the computation based on the indexing will be inefficient. On the contrary, the slicing is much effective than the indexing. Let's illustrate this by the following experiment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-03T15:26:16.647451Z",
     "start_time": "2021-02-03T15:26:16.642469Z"
    }
   },
   "outputs": [],
   "source": [
    "# we create an array, and want to retrieve the half of them\n",
    "\n",
    "num = 10000\n",
    "array = np.ones(num)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-03T15:26:19.152281Z",
     "start_time": "2021-02-03T15:26:16.652438Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "13.9 µs ± 584 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
     ]
    }
   ],
   "source": [
    "# method 1: using indexing\n",
    "\n",
    "idx = np.arange(0, num//2)\n",
    "%timeit array[idx]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-03T15:26:23.202823Z",
     "start_time": "2021-02-03T15:26:19.160258Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "194 ns ± 2.38 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)\n"
     ]
    }
   ],
   "source": [
    "# method 2: using slicing\n",
    "\n",
    "%timeit array[0: num]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, the above experiment demonstrates that the slicing is 72x faster than the indexing (13.9 µs / 194 ns)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So, here, we should avoid to use the indexing of `post2syn`. Instead, we can create a `post_slice_syn` connection structure which stores the *start* and the *end* position on the synpase state for each connected post-synaptic neuron $j$. `post_slice_syn` can be implemented by aligning the pre ids according to the sequential post id $0, 1, 2, ...$ (look the following illustrating figure). For each post neuron $j$, `start, end = post_slice_syn[j]` retrieves the start/end position of the connected synapse states."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"../images/syn-example-post_slice_syn.png\" width=\"700 px\" align=\"left\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Therefore, the updating logic of AMPA synapse can again be coded as:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-03T15:26:23.222770Z",
     "start_time": "2021-02-03T15:26:23.206812Z"
    }
   },
   "outputs": [],
   "source": [
    "@bp.delayed\n",
    "def output_by_vector2(ST, post, post_slice_syn):\n",
    "    g = np.zeros(len(post_slice_syn), dtype=np.float_)\n",
    "    for post_id, position in enumerate(post_slice_syn):\n",
    "        start = position[0]\n",
    "        end = position[1]\n",
    "        g[post_id] = np.sum(g_max * ST['s'][start: end])\n",
    "    \n",
    "    post['input'] -= post_cond * (post['V'] - E)\n",
    "    \n",
    "requires = dict(\n",
    "    pre=bp.types.NeuState('spike', ),\n",
    "    post=bp.types.NeuState('V', 'input'),\n",
    "    pre2syn = bp.types.ListConn(),\n",
    "    post_slice_syn = bp.types.Array(dim=2)\n",
    ")\n",
    "\n",
    "AMPA4 = bp.SynType(name='AMPA_vector', ST=ST,  requires=requires,\n",
    "                   steps=(update_by_vector, output_by_vector2), \n",
    "                   mode='vector')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similarly, a connection `pre_slice_syn` can also be implemented. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"../images/syn-example-pre_slice_syn.png\" width=\"700 px\" align=\"left\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## brainpy.SynConn"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above `brainpy.SynType` only defines the abstract synaptic model. To implement concreate synaptic computation, we should use `brainpy.SynConn`. A ``brainpy.SynConn`` receives the following parameters:\n",
    "\n",
    "- ``model``: The synapse type will be used to generate a synapse connection. It must be an instance of `brainpy.SynType`.\n",
    "- ``pre_group``: The presynaptic neuron group. An instance of `brainpy.NeuGroup`.\n",
    "- ``post_group``: The postsynaptic neuron group. An instance of `brainpy.NeuGroup`.\n",
    "- ``conn``: The connection method to create synaptic connectivity between the neuron groups.\n",
    "- ``monitors``: The items to monitor (record the history values.)\n",
    "- ``delay``: The time of the synapse delay (in milliseconds).\n",
    "- ``satisfies``: The data to satisfy the model requires."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's illustrate the usage of `SynConn` by connecting two LIF neurons. The LIF neuron model can be get from our [BrainPy-Models](https://brainpy-models.readthedocs.io/) (a package named \"bpmodels\"), which implements commonly used neuron and synapse models. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-03T15:26:23.276628Z",
     "start_time": "2021-02-03T15:26:23.226759Z"
    }
   },
   "outputs": [],
   "source": [
    "from bpmodels.neurons import get_LIF\n",
    "\n",
    "LIF = get_LIF(V_rest=-65., V_reset=-65., V_th=-55.)\n",
    "\n",
    "pre = bp.NeuGroup(LIF, 1, monitors=['spike', 'V'])\n",
    "pre.ST['V'] = -65.\n",
    "\n",
    "post = bp.NeuGroup(LIF, 1, monitors=['V'])\n",
    "post.ST['V'] = -65."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-03T15:26:23.292585Z",
     "start_time": "2021-02-03T15:26:23.280616Z"
    }
   },
   "outputs": [],
   "source": [
    "syn_conn = bp.SynConn(model=AMPA1,  # use above \"AMPA1\" to do the synaptic computation\n",
    "                      pre_group=pre, \n",
    "                      post_group=post,\n",
    "                      conn=bp.connect.All2All(),  # connect pre- and post- group by All2All method\n",
    "                      monitors=['s'], \n",
    "                      delay=1.5)\n",
    "\n",
    "# You can set the updating order for each step function\n",
    "# The functions can be scheduled can get from \"syn_conn.get_schedule()\"\n",
    "syn_conn.set_schedule(['input', 'update_by_scalar', 'output_by_scalar', 'monitor'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-03T15:26:23.375363Z",
     "start_time": "2021-02-03T15:26:23.297571Z"
    }
   },
   "outputs": [],
   "source": [
    "net = bp.Network(pre, syn_conn, post)\n",
    "net.run(duration=100., inputs=(pre, \"ST.input\", 20.))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-03T15:26:23.798264Z",
     "start_time": "2021-02-03T15:26:23.379353Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, gs = bp.visualize.get_figure(2, 1, 3, 8)\n",
    "\n",
    "fig.add_subplot(gs[0, 0])\n",
    "bp.visualize.line_plot(pre.mon.ts, pre.mon.spike, legend='pre-spike')\n",
    "\n",
    "fig.add_subplot(gs[1, 0])\n",
    "bp.visualize.line_plot(syn_conn.mon.ts, syn_conn.mon.s, legend='syn-s', show=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## brainpy.connect"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above example in [brainpy.SynConn](#brainpy.SynConn) shows a \"strange\" thing in which the data `requires` in abstract `SynType` model (such as *pre, post, post2syn, pre2syn*, ...) do not `satisfies` in concrete `SynConn` instance. Actually, this is because BrainPy automatically do these thing for you.\n",
    "\n",
    "- If you provide `pre_group` in brainpy.SynConn, the data `pre` will be automtically initialized. \n",
    "- If you provide `post_group` in brainpy.SynConn, the data `post` will be automtically initialized. \n",
    "- If you provide `conn` by using methods of `brainpy.connect.xxx`, the connection data like (`pre_ids`, `post_ids`, `conn_mat`, `pre2post`, `post2pre`, `pre2syn`, `post2syn`, `pre_slice_syn`, and `post_slice_syn`) will be initialized as needed. \n",
    "\n",
    "Otherwise, if users instantiate `brainpy.SynConn` without *pre_group*, *post_group*, *conn*, the data like *pre, post, post2syn, pre2syn* should provide by hand. Like, "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "syn_conn = bp.SynConn(AMPA4, pre_group=pre, post_group=post)\n",
    "syn_conn.pre2syn = ...\n",
    "syn_conn.post_slice_syn = ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Actually, BrainPy provides several commonly used connection methods in ``brainpy.connect`` module (see the follows). They are all inherited from the base class `brainpy.connect.Connector`. Users can also customize their synaptic connectivity by class inheritance. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### brainpy.connect.One2One\n",
    "\n",
    "The neurons in the pre-synaptic neuron group only connect to the neurons\n",
    "in the same position of the post-synaptic group. Thus, this connection\n",
    "requires the indices of two neuron groups same. Otherwise, an error will\n",
    "occurs.\n",
    "\n",
    "<img src=\"../images/one2one.png\" width=\"200 px\" align=\"left\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### brainpy.connect.All2All\n",
    "\n",
    "All neurons of the post-synaptic population form connections with all\n",
    "neurons of the pre-synaptic population (dense connectivity). Users can\n",
    "choose whether connect the neurons at the same position\n",
    "(`include_self=True or False`).\n",
    "\n",
    "<img src=\"../images/all2all.png\" width=\"200 px\" align=\"left\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### brainpy.connect.GridFour\n",
    "\n",
    "`GridFour` is the four nearest neighbors connection. Each neuron connect to its\n",
    "nearest four neurons.\n",
    "\n",
    "<img src=\"../images/grid_four.png\" width=\"250 px\" align=\"left\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### brainpy.connect.GridEight\n",
    "\n",
    "`GridEight` is eight nearest neighbors connection. Each neuron connect to its\n",
    "nearest eight neurons.\n",
    "\n",
    "<img src=\"../images/grid_eight.png\" width=\"250 px\" align=\"left\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### brainpy.connect.GridN\n",
    "\n",
    "`GridN` is also a nearest neighbors connection. Each neuron connect to its\n",
    "nearest $2N \\cdot 2N$ neurons.\n",
    "\n",
    "<img src=\"../images/grid_N.png\" width=\"250 px\" align=\"left\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### brainpy.connect.FixedProb\n",
    "\n",
    "For each post-synaptic neuron, there is a fixed probability that it forms a connection\n",
    "with a neuron of the pre-synaptic population. It is basically a all_to_all projection,\n",
    "except some synapses are not created, making the projection sparser.\n",
    "\n",
    "<img src=\"../images/fixed_proab.png\" width=\"200 px\" align=\"left\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### brainpy.connect.FixedPreNum\n",
    "\n",
    "Each neuron in the post-synaptic population receives connections from a\n",
    "fixed number of neurons of the pre-synaptic population chosen randomly.\n",
    "It may happen that two post-synaptic neurons are connected to the same\n",
    "pre-synaptic neuron and that some pre-synaptic neurons are connected to\n",
    "nothing.\n",
    "\n",
    "<img src=\"../images/fixed_pre_num.png\" width=\"200 px\" align=\"left\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### brainpy.connect.FixedPostNum\n",
    "\n",
    "Each neuron in the pre-synaptic population sends a connection to a fixed number of neurons\n",
    "of the post-synaptic population chosen randomly. It may happen that two pre-synaptic neurons\n",
    "are connected to the same post-synaptic neuron and that some post-synaptic neurons receive\n",
    "no connection at all.\n",
    "\n",
    "<img src=\"../images/fixed_post_num.png\" width=\"200 px\" align=\"left\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### brainpy.connect.GaussianProb\n",
    "\n",
    "\n",
    "Builds a Gaussian connection pattern between the two populations, where\n",
    "the connection probability decay according to the gaussian function.\n",
    "\n",
    "Specifically,\n",
    "\n",
    "$$\n",
    "p=\\exp(-\\frac{(x-x_c)^2+(y-y_c)^2}{2\\sigma^2})\n",
    "$$\n",
    "\n",
    "where $(x, y)$ is the position of the pre-synaptic neuron\n",
    "and $(x_c,y_c)$ is the position of the post-synaptic neuron.\n",
    "\n",
    "For example, in a $30 \\textrm{x} 30$ two-dimensional networks, when\n",
    "$\\beta = \\frac{1}{2\\sigma^2} = 0.1$, the connection pattern is shown\n",
    "as the follows:\n",
    "\n",
    "<img src=\"../images/gaussian_prob.png\" width=\"500 px\" align=\"left\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### brainpy.connect.GaussianWeight\n",
    "\n",
    "Builds a Gaussian connection pattern between the two populations, where\n",
    "the weights decay with gaussian function.\n",
    "\n",
    "Specifically,\n",
    "\n",
    "$$w(x, y) = w_{max} \\cdot \\exp(-\\frac{(x-x_c)^2+(y-y_c)^2}{2\\sigma^2})$$\n",
    "\n",
    "where $(x, y)$ is the position of the pre-synaptic neuron (normalized\n",
    "to [0,1]) and $(x_c,y_c)$ is the position of the post-synaptic neuron\n",
    "(normalized to [0,1]), $w_{max}$ is the maximum weight. In order to void\n",
    "creating useless synapses, $w_{min}$ can be set to restrict the creation\n",
    "of synapses to the cases where the value of the weight would be superior\n",
    "to $w_{min}$. Default is $0.01 w_{max}$.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-03T15:26:23.815188Z",
     "start_time": "2021-02-03T15:26:23.807215Z"
    }
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "def show_weight(pre_ids, post_ids, weights, geometry, neu_id):\n",
    "    height, width = geometry\n",
    "    ids = np.where(pre_ids == neu_id)[0]\n",
    "    post_ids = post_ids[ids]\n",
    "    weights = weights[ids]\n",
    "\n",
    "    X, Y = np.arange(height), np.arange(width)\n",
    "    X, Y = np.meshgrid(X, Y)\n",
    "    Z = np.zeros(geometry)\n",
    "    for id_, weight in zip(post_ids, weights):\n",
    "        h, w = id_ // width, id_ % width\n",
    "        Z[h, w] = weight\n",
    "\n",
    "    fig = plt.figure()\n",
    "    ax = fig.gca(projection='3d')\n",
    "    surf = ax.plot_surface(X, Y, Z, cmap=plt.cm.coolwarm, linewidth=0, antialiased=False)\n",
    "    fig.colorbar(surf, shrink=0.5, aspect=5)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-03T15:26:25.345429Z",
     "start_time": "2021-02-03T15:26:23.821174Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "gaussian_weight = bp.connect.GaussianWeight(\n",
    "    sigma=0.1, w_max=1., w_min=0.01,\n",
    "    normalize=True, include_self=True)\n",
    "pre_geom = post_geom = (40, 40)\n",
    "indices = np.arange(pre_geom[0] * pre_geom[1]).reshape(pre_geom)\n",
    "gaussian_weight(indices, indices)\n",
    "\n",
    "pre_ids = gaussian_weight.pre_ids\n",
    "post_ids = gaussian_weight.post_ids\n",
    "weights = gaussian_weight.weights\n",
    "show_weight(pre_ids, post_ids, weights, pre_geom, 820)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### brainpy.connect.DOG\n",
    "\n",
    "\n",
    "Builds a Difference-Of-Gaussian (dog) connection pattern between the two populations.\n",
    "\n",
    "Mathematically,\n",
    "\n",
    "$$\n",
    "w(x, y) = w_{max}^+ \\cdot \\exp(-\\frac{(x-x_c)^2+(y-y_c)^2}{2\\sigma_+^2})\n",
    "    - w_{max}^- \\cdot \\exp(-\\frac{(x-x_c)^2+(y-y_c)^2}{2\\sigma_-^2})\n",
    "$$\n",
    "\n",
    "where weights smaller than $0.01 * abs(w_{max} - w_{min})$ are not created and\n",
    "self-connections are avoided by default (parameter allow_self_connections).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-03T15:26:26.919565Z",
     "start_time": "2021-02-03T15:26:25.345429Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "dog = bp.connect.DOG(\n",
    "    sigmas=(0.08, 0.15),\n",
    "    ws_max=(1.0, 0.7), w_min=0.01,\n",
    "    normalize=True, include_self=True)\n",
    "h = 40\n",
    "pre_geom = post_geom = (h, h)\n",
    "indices = np.arange(pre_geom[0] * pre_geom[1]).reshape(pre_geom)\n",
    "dog(indices, indices)\n",
    "\n",
    "pre_ids = dog.pre_ids\n",
    "post_ids = dog.post_ids\n",
    "weights = dog.weights\n",
    "show_weight(pre_ids, post_ids, weights, (h, h), h * h // 2 + h // 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Other Operations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "``brainpy.SynType`` and ``brainpy.SynConn`` are very similar with ``brainpy.NeuType`` and ``brainpy.NeuGroup``. The operations like the `requires`, `satisfies`, `hand_overs` are also supported. Object-oriented programming can also be implemented like that in ``brainpy.NeuGroup``. Details please check [Build neurons](https://brainpy.readthedocs.io/en/latest/tutorials/build_neurons.html)."
   ]
  }
 ],
 "metadata": {
  "hide_input": false,
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.7"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": true
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
